- test_bubble_sort.py
- test_bubble_sort_conditional.py
- test_bubble_sort_import.py
- test_bubble_sort_in_class.py
- test_bubble_sort_parametrized.py
- test_bubble_sort_parametrized_loop.py

import random

# imports
import pytest  # used for our unit tests
from code_to_optimize.bubble_sort import sorter

# unit tests

# Basic Functionality
def test_standard_list_of_integers():
    codeflash_output = sorter([3, 1, 2])
    codeflash_output = sorter([10, 5, 8, 1])

def test_standard_list_of_floats():
    codeflash_output = sorter([3.5, 1.2, 2.8])
    codeflash_output = sorter([10.1, 5.5, 8.8, 1.1])

def test_mixed_list_of_integers_and_floats():
    codeflash_output = sorter([3, 1.2, 2])
    codeflash_output = sorter([10.1, 5, 8.8, 1])

# Edge Cases
def test_empty_list():
    codeflash_output = sorter([])

def test_single_element_list():
    codeflash_output = sorter([1])
    codeflash_output = sorter([3.5])

def test_list_with_duplicates():
    codeflash_output = sorter([3, 1, 2, 1])
    codeflash_output = sorter([10, 5, 8, 5, 1])

def test_list_with_all_identical_elements():
    codeflash_output = sorter([2, 2, 2, 2])
    codeflash_output = sorter([5.5, 5.5, 5.5])

def test_list_with_negative_numbers():
    codeflash_output = sorter([-1, -3, -2])
    codeflash_output = sorter([3, -1, 2, -2])

def test_list_with_mixed_positive_and_negative_numbers():
    codeflash_output = sorter([3, -1, 2, -2])
    codeflash_output = sorter([10, -5, 8, -1])


def test_large_list_of_integers():
    large_list = random.sample(range(1000), 1000)
    codeflash_output = sorter(large_list)

def test_large_list_of_floats():
    large_list = [random.uniform(-10000, 10000) for _ in range(1000)]
    codeflash_output = sorter(large_list)

# Performance and Scalability
def test_sorted_list():
    codeflash_output = sorter([1, 2, 3, 4, 5])
    codeflash_output = sorter([1.1, 2.2, 3.3, 4.4, 5.5])

def test_reverse_sorted_list():
    codeflash_output = sorter([5, 4, 3, 2, 1])
    codeflash_output = sorter([5.5, 4.4, 3.3, 2.2, 1.1])

# Special Cases
def test_list_with_strings():
    codeflash_output = sorter(['banana', 'apple', 'cherry'])
    codeflash_output = sorter(['dog', 'cat', 'elephant'])

def test_list_with_mixed_data_types():
    with pytest.raises(TypeError):
        sorter([3, 'apple', 2])
    with pytest.raises(TypeError):
        sorter([10.1, 'banana', 5])
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest  # used for our unit tests
from code_to_optimize.bubble_sort import sorter


# unit tests
def test_basic_sorted_list_of_integers():
    codeflash_output = sorter([1, 2, 3, 4, 5])

def test_basic_unsorted_list_of_integers():
    codeflash_output = sorter([5, 3, 1, 4, 2])

def test_basic_list_with_duplicate_integers():
    codeflash_output = sorter([2, 3, 2, 1, 4, 3])

def test_edge_empty_list():
    codeflash_output = sorter([])

def test_edge_single_element_list():
    codeflash_output = sorter([1])
    codeflash_output = sorter(["a"])

def test_edge_all_elements_same():
    codeflash_output = sorter([1, 1, 1, 1, 1])
    codeflash_output = sorter(["a", "a", "a"])

def test_different_data_types_list_of_strings():
    codeflash_output = sorter(["apple", "banana", "cherry"])
    codeflash_output = sorter(["banana", "apple", "cherry"])

def test_different_data_types_list_of_mixed_case_strings():
    codeflash_output = sorter(["Banana", "apple", "Cherry"])

def test_different_data_types_list_of_floats():
    codeflash_output = sorter([1.1, 3.3, 2.2, 4.4, 5.5])

def test_different_data_types_list_of_negative_and_positive_integers():
    codeflash_output = sorter([-1, -3, 2, 1, 0])

def test_complex_list_of_tuples():
    codeflash_output = sorter([(2, "b"), (1, "a"), (3, "c")])

def test_complex_list_of_lists():
    codeflash_output = sorter([[2, "b"], [1, "a"], [3, "c"]])

def test_complex_list_with_mixed_data_types():
    with pytest.raises(TypeError):
        sorter([1, "a", 2.2])
    with pytest.raises(TypeError):
        sorter([1, [2, 3], "a"])

def test_large_scale_large_list_of_integers():
    large_list = list(range(1000000, 999000, -1))
    sorted_large_list = list(range(1, 1001))
    codeflash_output = sorter(large_list)

def test_large_scale_large_list_with_duplicates():
    large_list_with_duplicates = [1, 2, 3] * 1000000
    sorted_large_list_with_duplicates = [1, 1, 1] * 1000000 + [2, 2, 2] * 1000000 + [3, 3, 3] * 1000000
    codeflash_output = sorter(large_list_with_duplicates)

def test_performance_very_large_list_of_random_integers():
    import random
    random.seed(0)
    very_large_list = random.sample(range(1000), 1000)
    codeflash_output = sorter(very_large_list)

def test_performance_very_large_list_of_random_floats():
    import random
    random.seed(0)
    very_large_list_of_floats = [random.uniform(0, 1000000) for _ in range(1000)]
    codeflash_output = sorter(very_large_list_of_floats)

def test_special_characters_list_of_strings_with_special_characters():
    codeflash_output = sorter(["!apple", "#banana", "@cherry"])

def test_special_characters_list_of_unicode_strings():
    codeflash_output = sorter(["éclair", "banana", "apple"])

def test_stability_of_sort_list_with_identical_elements_except_for_secondary_attribute():
    codeflash_output = sorter([(1, "b"), (1, "a"), (1, "c")])
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.